home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / jabber / objects / bytestreams.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  7.3 KB  |  225 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. from pprint import pprint
  5. from pyxmpp.utils import from_utf8
  6. from pyxmpp.utils import to_utf8
  7. import libxml2
  8. from pyxmpp.jid import JID
  9. from pyxmpp.jabber.disco import DiscoCacheFetcherBase
  10. from pyxmpp.objects import StanzaPayloadObject
  11. from pyxmpp.xmlextra import common_doc, get_node_ns_uri
  12. BYTESTREAMS_NS = 'http://jabber.org/protocol/bytestreams'
  13. BYTESTREAMS_UDP_NS = BYTESTREAMS_NS + '#udp'
  14.  
  15. class StreamHost(StanzaPayloadObject):
  16.     xml_element_name = 'streamhost'
  17.     xml_element_namespace = BYTESTREAMS_NS
  18.     
  19.     def __init__(self, xmlnode_or_jid, host = None, port = None, zeroconf = None):
  20.         if isinstance(xmlnode_or_jid, libxml2.xmlNode):
  21.             self.from_xml(xmlnode_or_jid)
  22.         else:
  23.             self.jid = JID(xmlnode_or_jid)
  24.             self.host = host
  25.             self.port = port
  26.             self.zeroconf = zeroconf
  27.         if not bool(self.port) ^ bool(self.zeroconf):
  28.             raise ValueError, 'StreamHost element requires one of [port, zeroconf]'
  29.         
  30.  
  31.     
  32.     def from_xml(self, node):
  33.         if node.type != 'element':
  34.             raise ValueError, 'XML node is not a streamhost (not en element)'
  35.         
  36.         ns = get_node_ns_uri(node)
  37.         if ns or ns != self.xml_element_namespace or node.name != self.xml_element_name:
  38.             raise ValueError, 'XML node is not a %s descriptor' % self.xml_element_name
  39.         
  40.         jid = JID(node.prop('jid').decode('utf-8'))
  41.         self.jid = jid
  42.         host = node.prop('host').decode('utf-8')
  43.         self.host = host
  44.         port = node.prop('port')
  45.         self.port = None if port else None
  46.         zeroconf = node.prop('zeroconf')
  47.         self.zeroconf = None if zeroconf else None
  48.  
  49.     
  50.     def __eq__(self, other):
  51.         if other is self:
  52.             return True
  53.         
  54.         if not isinstance(other, self.__class__):
  55.             return False
  56.         
  57.         if self.jid == other.jid and self.host == other.host and self.port == other.port:
  58.             pass
  59.         return self.zeroconf == other.zeroconf
  60.  
  61.     
  62.     def __ne__(self, other):
  63.         return not self.__eq__(other)
  64.  
  65.     
  66.     def __hash__(self):
  67.         return hash((self.jid, self.host, self.port, self.zeroconf))
  68.  
  69.     
  70.     def complete_xml_element(self, xmlnode, _unused):
  71.         xmlnode.setProp('jid', JID(self.jid).as_utf8())
  72.         xmlnode.setProp('host', unicode(self.host).encode('utf-8'))
  73.         if self.port:
  74.             xmlnode.setProp('port', unicode(self.port).encode('utf-8'))
  75.         
  76.         if self.zeroconf:
  77.             xmlnode.setProp('zeroconf', unicode(self.zeroconf).encode('utf-8'))
  78.         
  79.  
  80.     
  81.     def __str__(self):
  82.         n = self.as_xml(doc = common_doc)
  83.         r = n.serialize()
  84.         n.unlinkNode()
  85.         n.freeNode()
  86.         return r
  87.  
  88.  
  89.  
  90. class ByteStreams(StanzaPayloadObject):
  91.     xml_element_name = 'query'
  92.     xml_element_namespace = BYTESTREAMS_NS
  93.     
  94.     def __init__(self, xmlnode_or_node = None, sid = None, mode = None):
  95.         self.hosts = []
  96.         self.sid = sid
  97.         self.mode = mode
  98.         self.activate = None
  99.         self.host_used = None
  100.         if isinstance(xmlnode_or_node, libxml2.xmlNode):
  101.             self.from_xml(xmlnode_or_node)
  102.         else:
  103.             self.node = xmlnode_or_node
  104.  
  105.     
  106.     def from_xml(self, node, strict = True):
  107.         node_ = node.prop('node')
  108.         sid = node.prop('sid')
  109.         self.sid = None if sid else None
  110.         mode = node.prop('mode')
  111.         self.mode = None if mode else None
  112.         self.mode = None if self.mode != 'tcp' else None
  113.         if node_:
  114.             self.node = node_.decode('utf-8')
  115.         else:
  116.             self.node = None
  117.         if node.type != 'element':
  118.             raise ValueError, 'XML node is not a bytestreams (not en element)'
  119.         
  120.         ns = get_node_ns_uri(node)
  121.         if ns or ns != BYTESTREAMS_NS or node.name != 'query':
  122.             raise ValueError, 'XML node is not a bytestreams query'
  123.         
  124.         n = node.children
  125.         while n:
  126.             if n.type != 'element':
  127.                 n = n.next
  128.                 continue
  129.             
  130.             ns = get_node_ns_uri(n)
  131.             if ns and ns != BYTESTREAMS_NS:
  132.                 n = n.next
  133.                 continue
  134.             
  135.             if n.name == 'streamhost':
  136.                 
  137.                 try:
  138.                     self.add_host(n)
  139.                 except ValueError:
  140.                     if strict:
  141.                         raise 
  142.                     
  143.                 except:
  144.                     strict
  145.                 
  146.  
  147.             None<EXCEPTION MATCH>ValueError
  148.             if n.name == 'streamhost-used':
  149.                 host_used = JID(n.prop('jid').decode('utf-8'))
  150.                 self.host_used = host_used
  151.             elif n.name == 'activate':
  152.                 activate = JID(n.getContent())
  153.                 self.activate = activate
  154.             
  155.             n = n.next
  156.  
  157.     
  158.     def complete_xml_element(self, xmlnode, _unused):
  159.         if self.node:
  160.             xmlnode.setProp('node', to_utf8(self.node))
  161.         
  162.         if self.sid:
  163.             xmlnode.setProp('sid', to_utf8(self.sid))
  164.         
  165.         if self.mode and self.mode != 'tcp':
  166.             xmlnode.setProp('mode', to_utf8(self.mode))
  167.         
  168.         for host in self.hosts:
  169.             
  170.             try:
  171.                 host.as_xml(xmlnode, _unused)
  172.             continue
  173.             pprint(host)
  174.             raise 
  175.             continue
  176.  
  177.         
  178.         if self.activate:
  179.             xmlnode.newChild(None, 'activate', JID(self.activate).as_utf8())
  180.         
  181.         if self.host_used:
  182.             h = xmlnode.newChild(None, 'streamhost-used', None)
  183.             h.setProp('jid', JID(self.host_used).as_utf8())
  184.         
  185.  
  186.     
  187.     def __str__(self):
  188.         n = self.as_xml(doc = common_doc)
  189.         r = n.serialize()
  190.         n.unlinkNode()
  191.         n.freeNode()
  192.         return r
  193.  
  194.     
  195.     def add_host(self, streamhost_jid, host = None, port = None, zeroconf = None):
  196.         sh = StreamHost(streamhost_jid, host, port, zeroconf)
  197.         self.hosts.append(sh)
  198.         return sh
  199.  
  200.  
  201.  
  202. def register_streamhost_cache_fetchers(cache_suite, stream):
  203.     tmp = stream
  204.     
  205.     class ByteStreamsCacheFetcher((DiscoCacheFetcherBase,)):
  206.         stream = tmp
  207.         disco_class = ByteStreams
  208.         __response = DiscoCacheFetcherBase._DiscoCacheFetcherBase__response
  209.         __error = DiscoCacheFetcherBase._DiscoCacheFetcherBase__error
  210.         __timeout = DiscoCacheFetcherBase._DiscoCacheFetcherBase__timeout
  211.         
  212.         def fetch(self):
  213.             Iq = Iq
  214.             import pyxmpp.iq
  215.             (jid, node) = self.address
  216.             iq = Iq(to_jid = jid, stanza_type = 'get')
  217.             disco = self.disco_class(node)
  218.             disco.as_xml(iq.xmlnode)
  219.             self.stream.set_response_handlers(iq, self._ByteStreamsCacheFetcher__response, self._ByteStreamsCacheFetcher__error, self._ByteStreamsCacheFetcher__timeout)
  220.             self.stream.send(iq)
  221.  
  222.  
  223.     cache_suite.register_fetcher(ByteStreams, ByteStreamsCacheFetcher)
  224.  
  225.